﻿#ifndef NctiCreateModelScriptPub_H
#define NctiCreateModelScriptPub_H
#include "ncti_base.h"
#include "dcl_ncti_pubfun.h"
#include <vector>
#include "NctiAxis.h"
#include "NctiDesignMultiBoolean.h"
namespace NCTI
{
	class NctiBaseModel;
	class NctiTopoFace;
	class NctiTopoCell;
	class NctiDisplayModelBody;
	class NctiGeomLine;
	class NctiGeomCircle;
	class NctiGeomBezierCurve;
	class NctiGeomBSplineCurve;
	class NctiGeomEllipse;
	class NctiGeomCurve;
	class NctiGeomSurface;
	struct CurvePt
	{
		NctiPosition ptS;
		NctiPosition ptE;
		std::string name;
		Ncti_Boolean bCheck;
		CurvePt() :bCheck(false) {}
		CurvePt(NctiPosition pts, NctiPosition pte, std::string s) :ptS(pts), ptE(pte), name(s), bCheck(false) {}
	};
	struct LinkCurve
	{
		std::vector<std::string> nameVec;
		std::vector<CurvePt> curvePtVec;
		bool bClose;
		LinkCurve() :bClose(false) {}
	};
	/**
	* @brief create the script for model
	* @details create the script for model
	*/
	class DECL_NCTI_PUBFUN NctiCreateModelScriptPub
	{
	public:
		NctiCreateModelScriptPub();
		~NctiCreateModelScriptPub();

		/**
		* @brief get new name for type name
		* @details get new name for type name
		* @param[in] pBaseModel, the base model
		* @return the new name
		*/
		static std::string GetNewName(NctiBaseModel* pBaseModel);
		/**
		* @brief get selected object name and edge id
		* @details get selected object name and edge id
		* @param[in] pBaseModel, the base model
		* @param[out] objNameVec, the object name vector
		* @param[out] edgeIDVec, the edge id vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetSelectData(NctiBaseModel* pBaseModel,
			std::vector<std::string>& objNameVec, std::vector<Ncti_Long>& edgeIDVec);
		/**
		* @brief get geometry from trimmed curve
		* @details get geometry from trimmed curve
		* @param[out] geomCurve, the geometry curve
		* @return true if success, false otherwise
		*/
		static void GetGeomFromTrimmedCurve(NctiGeomCurve*& geomCurve);
		/**
		* @brief get geometry from trimmed surface
		* @details get geometry from trimmed surface
		* @param[out] pSurface, the geometry surface
		* @return true if success, false otherwise
		*/
		static void GetGeomFromTrimmedSurface(NctiGeomSurface*& pSurface);
		/**
		* @brief get selected object name
		* @details get selected object name
		* @param[in] pBaseModel, the base model
		* @param[out] objNameVec, the object name vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetSelectData(NctiBaseModel* pBaseModel, std::vector<std::string>& objNameVec);

		//点
		/**
		* @brief create the python command script by point
		* @details create the point script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the point name
		* @param[in] pt, the point position
		* @return the script
		*/
		static std::string CreateVertexPyCommand(NctiBaseModel* pBaseModel, const char* name, const NctiPosition& pt);
		//线
		/**
		* @brief create the python command script by line
		* @details create the line script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the line name
		* @param[in] pt, the point position
		* @param[in] dir, the line direction
		* @return the script
		*/
		static std::string CreateLinePyCommand(NctiBaseModel* pBaseModel, const char* name, const NctiPosition& pt, const NctiVector& dir);
		//圆
		/**
		* @brief create the python command script by circle
		* @details create the circle script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the circle name
		* @param[in] pt, the center position
		* @param[in] normal, the normal vector
		* @param[in] r, the radius
		* @return the script
		*/
		static std::string CreateCirclePyCommand(NctiBaseModel* pBaseModel, const char* name, const NctiPosition& pt, const NctiVector& normal, Ncti_Double r);
		//椭圆
		/**
		* @brief create the python command script by ellipse
		* @details create the ellipse script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the ellipse name
		* @param[in] pt, the center position
		* @param[in] normal, the normal vector
		* @param[in] dir, the direction vector
		* @param[in] major, the major radius
		* @param[in] minor, the minor radius
		* @return the script
		*/
		static std::string CreateEllipsePyCommand(NctiBaseModel* pBaseModel, const char* name, const NctiPosition& pt, const NctiVector& normal, const NctiVector& dir, Ncti_Double major, Ncti_Double minor);
		//面
		/**
		* @brief create the python command script by plane
		* @details create the plane script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the plane name
		* @param[in] pt, the point position
		* @param[in] normal, the plane normal
		* @return the script
		*/
		static std::string CreatePlanePyCommand(NctiBaseModel* pBaseModel, const char* name, const NctiPosition& pt, const NctiVector& normal);

		//box
		/**
		* @brief create the box script
		* @details create the box script
		* @param[in] pBaseModel, the base model
		* @param[in] strCmd, the output script
		* @return true if success, false otherwis
		*/
		static Ncti_Boolean CreateBoxScript(NctiBaseModel* pBaseModel, std::string& strCmd);
		/**
		* @brief create the box script
		* @details create the box script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] edgeIDVec, the edge id vector
		* @param[out] ptCenter, the box center position
		* @param[out] ZAxis, the box Z axis
		* @param[out] XAxis, the box X axis
		* @param[out] Length, the box length
		* @param[out] Width, the box width
		* @param[out] Heigth, the box height
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateBoxScript(NctiBaseModel* pBaseModel,
			const std::vector<std::string>& objNameVec, const std::vector<Ncti_Long>& edgeIDVec,
			NctiPosition& ptCenter, NctiVector& ZAxis, NctiVector& XAxis, double& Length, double& Width, double& Heigth);
		/**
		* @brief create the box script
		* @details create the box script
		* @param[in] pBaseModel, the base model
		* @param[in] pt, the box center position
		* @param[in] ZAxis, the box Z axis
		* @param[in] XAxis, the box X axis
		* @param[in] Length, the box length
		* @param[in] Width, the box width
		* @param[in] Heigth, the box height
		* @return the script
		*/
		static std::string CreateBoxPyCommand(NctiBaseModel* pBaseModel, const NctiPosition& pt, const NctiVector& ZAxis, const NctiVector& XAxis, const double& Length, const double& Width, const double& Heigth);

		//圆柱
		/**
		* @brief create the cylinder script
		* @details create the cylinder script
		* @param[in] pBaseModel, the base model
		* @param[in] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateCylinderScript(NctiBaseModel* pBaseModel, std::string& strCmd);
		/**
		* @brief create the cylinder script
		* @details create the cylinder script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] cellIdVec, the cell id vector
		* @param[out] strCmd, the output script
		* @param[out] strName, the output cylinder name
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateCylinderScript(NctiBaseModel* pBaseModel,
			const std::vector<std::string>& objNameVec, const std::vector<Ncti_Long>& cellIdVec, std::string& strCmd, std::string& strName);
		/**
		* @brief create the cylinder script
		* @details create the cylinder script
		* @param[in] pBaseModel, the base model
		* @param[in] objName, the object name
		* @param[in] cellId, the cell id
		* @param[out] Axis, the cylinder axis
		* @param[out] Radius, the cylinder radius
		* @param[out] Height, the cylinder height
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateCylinderScript(NctiBaseModel* pBaseModel,
			const std::string& objName, const Ncti_Long& cellId, NctiAxis& Axis, Ncti_Double& Radius, Ncti_Double& Height);
		/**
		* @brief create the cylinder script
		* @details create the cylinder script
		* @param[in] pBaseModel, the base model
		* @param[in] axis, the cylinder axis
		* @param[in] dRadius, the cylinder radius
		* @param[in] Height, the cylinder height
		* @param[out] strName, the output cylinder name
		* @return the script
		*/
		static std::string CreateCylinderPyScript(NctiBaseModel* pBaseModel, const NctiAxis& axis, const Ncti_Double& dRadius, const Ncti_Double& Height, std::string& strName);
		/**
		* @brief create the cylinder script
		* @details create the cylinder script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the cylinder name
		* @param[in] axis, the cylinder axis
		* @param[in] dRadius, the cylinder radius
		* @param[in] Height, the cylinder height
		* @return the script
		*/
		static std::string CreateCylinderPyScript(NctiBaseModel* pBaseModel, const char* name, const NctiAxis& axis, const Ncti_Double& dRadius, const Ncti_Double& Height);

		//圆锥
		/**
		* @brief create the cone script
		* @details create the cone script
		* @param[in] pBaseModel, the base model
		* @param[out] strCmdVec, the output script vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateConeScript(NctiBaseModel* pBaseModel, std::vector<std::string>& strCmdVec);
		/**
		* @brief create the cone script
		* @details create the cone script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] cellIdVec, the cell id vector
		* @param[out] strCmdVec, the output script vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateConeScript(NctiBaseModel* pBaseModel,
			const std::vector<std::string>& objNameVec, const std::vector<Ncti_Long>& cellIdVec, std::vector<std::string>& strCmdVec);
		/**
		* @brief create the cone script
		* @details create the cone script
		* @param[in] pBaseModel, the base model
		* @param[in] objName, the object name
		* @param[in] cellId, the cell id
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateConeScript(NctiBaseModel* pBaseModel,
			const std::string& objName, const Ncti_Long& cellId, std::string& strCmd);
		/**
		* @brief create the cone script
		* @details create the cone script
		* @param[in] pBaseModel, the base model
		* @param[in] dButtonRadius, the bottom radius
		* @param[in] dTopRadius, the top radius
		* @param[in] dHeight, the height of the cone
		* @param[in] pt, the center position of the bottom
		* @param[in] ZAxis, the cone Z axis
		* @param[in] XAxis, the cone X axis
		* @param[in] dAngle, the angle of the cone
		* @return the script
		*/
		static std::string CreateConePyCommand(NctiBaseModel* pBaseModel, double dButtonRadius, double dTopRadius, double dHeight,
			NctiPosition pt, NctiVector ZAxis, NctiVector XAxis, double dAngle);
		/**
		* @brief create the cone script
		* @details create the cone script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the cone name
		* @param[in] dButtonRadius, the bottom radius
		* @param[in] dTopRadius, the top radius
		* @param[in] dHeight, the height of the cone
		* @param[in] pt, the center position of the bottom
		* @param[in] normal, the cone normal vector
		* @return the script
		*/
		static std::string CreateConePyCommand(NctiBaseModel* pBaseModel, const char* name, double dButtonRadius, double dTopRadius, double dHeight,
			const NctiPosition& pt, const NctiVector& normal);

		//球
		/**
		* @brief create the sphere script
		* @details create the sphere script
		* @param[in] pBaseModel, the base model
		* @param[out] strCmdVec, the output script vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateSphereScript(NctiBaseModel* pBaseModel, std::vector<std::string>& strCmdVec);
		/**
		* @brief create the sphere script
		* @details create the sphere script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] cellIdVec, the cell id vector
		* @param[out] strCmdVec, the output script vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateSphereScript(NctiBaseModel* pBaseModel,
			const std::vector<std::string>& objNameVec, const std::vector<Ncti_Long>& cellIdVec, std::vector<std::string>& strCmdVec);
		/**
		* @brief create the sphere script
		* @details create the sphere script
		* @param[in] pBaseModel, the base model
		* @param[in] dRadius, the sphere radius
		* @param[in] pt, the sphere center position
		* @param[in] ZAxis, the sphere Z axis
		* @return the script
		*/
		static std::string CreateSphereScript(NctiBaseModel* pBaseModel, double dRadius, NctiPosition pt, NctiVector ZAxis);
		/**
		* @brief create the sphere script
		* @details create the sphere script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the sphere name
		* @param[in] dRadius, the sphere radius
		* @param[in] pt, the sphere center position
		* @param[in] ZAxis, the sphere Z axis
		* @return the script
		*/
		static std::string CreateSphereScript(NctiBaseModel* pBaseModel,const char* name, double dRadius, NctiPosition pt, NctiVector ZAxis);

		//圆环
		/**
		* @brief create the torus script
		* @details create the torus script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the torus name
		* @param[in] radius, the torus major radius
		* @param[in] sectionRadius, the torus minor radius
		* @param[in] pt, the torus center position
		* @param[in] ZAxis, the torus Z axis
		* @return the script
		*/
		static std::string CreateTorusPyCommand(NctiBaseModel* pBaseModel, const char* name, double radius,double sectionRadius, NctiPosition pt, NctiVector ZAxis);
		//布尔
		/**
		* @brief create the boolean script of multi objects
		* @details create the boolean script of multi objects
		* @param[in] pBaseModel, the base model
		* @param[in] BoolType, the boolean type
		* @param[in] baseObjectNames, the base object names
		* @param[in] toolObjectNames, the tool object names
		* @return the script
		*/
		static std::string CreateMultiBooleanPyScript(NctiBaseModel* pBaseModel, const NctiDesignMultiBoolean::BOOLEAN_TYPE& BoolType, const std::vector<std::string>& baseObjectNames, const std::vector<std::string>& toolObjectNames);
		
		//圆角 倒角
		/**
		* @brief create the chamfer script
		* @details create the chamfer script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] cellIdVec, the cell id vector
		* @param[out] o_objNameVec, the output object name vector
		* @param[out] o_ptVecVec, the output point vector vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateChamferScript(NctiBaseModel* pBaseModel,
			const std::vector<std::string>& objNameVec, const std::vector<Ncti_Long>& cellIdVec, std::vector<std::string>& o_objNameVec, std::vector<std::vector<NctiPosition>>& o_ptVecVec);
		/**
		* @brief create the chamfer python command
		* @details create the chamfer python command
		* @param[in] pBaseModel, the base model
		* @param[in] ChamferType, the chamfer type
		* @param[in] Radius, the chamfer radius
		* @param[in] objNameVec, the object name vector
		* @param[in] ptVecVec, the point vector vector
		* @return the script vector
		*/
		static std::vector<std::string> CreateChamferPyCommand(NctiBaseModel* pBaseModel, Ncti_Integer ChamferType, const double& Radius, const std::vector<std::string>& objNameVec, const std::vector<std::vector<NctiPosition>>& ptVecVec);

		//Array
		/**
		* @brief get length and direction from selected object 
		* @details get length and direction from selected object 
		* @param[in] pBaseModel, the base model
		* @param[out] Length, the length
		* @param[out] vec, the direction vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetLengthAndDir(NctiBaseModel* pBaseModel, double& Length, NctiVector& vec);
		/**
		* @brief get direction from selected object
		* @details get direction from selected object
		* @param[in] pBaseModel, the base model
		* @param[out] vec, the direction vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetVector(NctiBaseModel* pBaseModel, NctiVector& vec);
		/**
		* @brief create the rectangular array script
		* @details create the rectangular array script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] Num, the number of the array
		* @param[in] Length, the length of the array
		* @param[in] MoveVec, the move vector
		* @return the script vector
		*/
		static std::vector<std::string> CreateRectangularArrayPyScript(NctiBaseModel* pBaseModel, const std::vector<std::string>& objNameVec, const int& Num, const double& Length, const NctiVector& MoveVec);
		/**
		* @brief create the circular array script
		* @details create the circular array script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] Num, the number of the array
		* @param[in] Angle, the angle of the array
		* @param[in] pt, the center position of the array
		* @param[in] normal, the normal vector of the array
		* @return the script vector
		*/
		static std::vector<std::string> CreateRotateArrayPyScript(NctiBaseModel* pBaseModel, const std::vector<std::string>& objNameVec,
			const int& Num, const double& Angle, const NctiPosition& pt, const NctiVector& normal);
		
		//创建线条、轮廓、拉伸
		/**
		* @brief create the curve wire primitive script
		* @details create the curve wire primitive script
		* @param[in] pBaseModel, the base model
		* @param[in] bCreateFace, whether to create face
		* @param[in] strNameVec, the object name vector
		* @param[in] edgeVec, the edge id vector
		* @param[out] strCmdVec, the output script vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateCurveWirePrimScript(
			NctiBaseModel* pBaseModel, bool bCreateFace, const std::vector<std::string>& strNameVec, 
			const std::vector<Ncti_Long>& edgeVec, std::vector<std::string>& strCmdVec);
		/**
		* @brief create the curve wire primitive script from face
		* @details create the curve wire primitive script from face
		* @param[in] pModelBody, the model body
		* @param[in] pTopoFace, the topo face
		* @param[in] Index, the index
		* @param[in] headName, the head name
		* @param[in] bCreateFace, whether to create face
		* @param[in] bPrism, whether to create prism
		* @param[in] prismVec, the prism vector
		* @param[out] oWireNames, the wrie names
		* @return the script vector
		*/
		static std::vector<std::string> CreateCurveWirePrimFromFaceScript(
			NctiDisplayModelBody* pModelBody, NctiTopoFace* pTopoFace, int Index, const std::string headName, 
			bool bCreateFace, bool bPrism, NctiVector prismVec, std::vector<std::string>& oWireNames);
		/**
		* @brief create surface =script from face
		* @details create the curve wire primitive script from face
		* @param[in] pModelBody, the model body
		* @param[in] pTopoFace, the topo face
		* @param[in] Index, the index
		* @param[in] headName, the head name
		* @return the script vector
		*/
		static std::vector<std::string> CreateSurfaceScript(
			NctiDisplayModelBody* pModelBody, NctiTopoFace* pTopoFace, int Index, const std::string headName);
		/**
		* @brief order the curve points
		* @details order the curve points
		* @param[in] curve, the curve point
		* @param[in] curvePtVec, the curve point vector
		* @param[out] linkCurve, the link curve
		* @return void
		*/
		static void OrderCurve(CurvePt curve, std::vector<CurvePt>& curvePtVec, LinkCurve& linkCurve);
		/**
		* @brief order the link curves
		* @details order the link curves
		* @param[in] curvePtVec, the curve point vector
		* @param[out] linkCurveVec, the link curve vector
		* @return void
		*/
		static void OrderLinkCurve(std::vector<CurvePt> curvePtVec, std::vector<LinkCurve>& linkCurveVec);
		/**
		* @brief get the edge curve command
		* @details get the edge curve command
		* @param[in] pModelBody, the model body
		* @param[in] pCell, the topo cell
		* @param[in] name, the edge name
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetEdgeCurveCmd(NctiDisplayModelBody* pModelBody, NctiTopoCell* pCell, const std::string& name, std::string& strCmd);
		/**
		* @brief get the edge curve command
		* @param[in] pModelBody, the model body
		* @param[in] pCell, the topo cell
		* @details get the edge curve command
		* @param[in] pCurve, the curve object
		* @param[in] name, the edge name
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetCurveCmd(NctiDisplayModelBody* pModelBody, NctiTopoCell* pCell, NctiGeomCurve* pCurve, const std::string& name, std::string& strCmd);
		/**
		* @brief create the line script
		* @details create the line script
		* @param[in] pt1, the line start point
		* @param[in] pt2, the line end point
		* @param[in] name, the line name
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateLineScript(const NctiPosition& pt1, const NctiPosition& pt2, const std::string& name, std::string& strCmd);
		/**
		* @brief create the circle script
		* @details create the circle script
		* @param[in] center, the circle center point
		* @param[in] normal, the circle normal vector
		* @param[in] radius, the circle radius
		* @
		*/
		static Ncti_Boolean CreateLineScript(NctiDisplayModelBody* pModelBody, NctiTopoCell* pCell, NctiGeomLine* pLine, const std::string& name, std::string& strCmd);
		/**
		* @brief create the circle script
		* @details create the circle script
		* @param[in] pModelBody, the model body
		* @param[in] pCell, the topo cell
		* @param[in] pCircle, the geometry circle
		* @param[in] name, the circle name
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateCircleScript(NctiDisplayModelBody* pModelBody, NctiTopoCell* pCell, NctiGeomCircle* pCircle, const std::string& name, std::string& strCmd);
		/**
		* @brief create the bezier script
		* @details create the bezier script
		* @param[in] pModelBody, the model body
		* @param[in] pCell, the topo cell
		* @param[in] pBezierCurve, the geometry bezier curve
		* @param[in] name, the bezier name
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/ 
		static Ncti_Boolean CreateBezierScript(NctiDisplayModelBody* pModelBody, NctiTopoCell* pCell, NctiGeomBezierCurve* pBezierCurve, const std::string& name, std::string& strCmd);
		/**
		* @brief create the bspline script
		* @details create the bspline script
		* @param[in] pModelBody, the model body
		* @param[in] pCell, the topo cell
		* @param[in] pBSplineCurve, the geometry bspline curve
		* @param[in] name, the bspline name
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateBSplineScript(NctiDisplayModelBody* pModelBody, NctiTopoCell* pCell, NctiGeomBSplineCurve* pBSplineCurve, const std::string& name, std::string& strCmd);
		/**
		* @brief create the ellipse script
		* @details create the ellipse script
		* @param[in] pModelBody, the model body
		* @param[in] pCell, the topo cell
		* @param[in] pEllipseCurve, the geometry ellipse curve
		* @param[in] name, the ellipse name
		* @param[out] strCmd, the output script
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateEllipseScript(NctiDisplayModelBody* pModelBody, NctiTopoCell* pCell, NctiGeomEllipse* pEllipseCurve, const std::string& name, std::string& strCmd);

		/**
		* @brief get angle from two selected cells which are curves
		* @details get angle from selected cells which are curves
		* @param[in] pBaseModel, the base model
		* @param[out] dAngle, the angle
		*/
		static Ncti_Boolean GetAngle(NctiBaseModel* pBaseModel, double& dAngle);
		/**
		* @brief get the center of a circle or the midpoint of the centers of two circles from selectData
		* @details get the center of a circle or the midpoint of the centers of two circles from selectData
		* @param[in] pBaseModel, the base model
		* @param[out] pt, the center point
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetCenterPt(NctiBaseModel* pBaseModel, NctiPosition& pt);
		/**
		* @brief create the revolve script
		* @details create the revolve script
		* @param[in] pBaseModel, the base model
		* @param[in] strNameVec, the object name vector
		* @param[in] edgeVec, the edge id vector
		* @param[out] strCmdVec, the output script vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateRevolvePyScript(NctiBaseModel* pBaseModel, const std::vector<std::string>& strNameVec,
			const std::vector<Ncti_Long>& edgeVec, std::vector<std::string>& strCmdVec);
		/**
		* @brief create the revolve script
		* @details create the revolve script
		* @param[in] pBaseModel, the base model
		* @param[in] resName, the revolve name
		* @param[in] outlineName, the outline name
		* @param[in] pos, the revolve axis position
		* @param[in] normal, the revolve axis normal
		* @param[in] rotateAngle, the revolve angle
		* @return the script
		*/
		static std::string CreateRevolvePyScript(NctiBaseModel* pBaseModel,const char* resName, const char* outlineName, const NctiPosition& pos, const NctiVector& normal, Ncti_Double rotateAngle);
		/**
		* @brief create the cross section script
		* @details create the cross section script
		* @param[in] pEdgeBodyVec, the edge model body vector
		* @param[in] pEdgeCellVec, the edge topo cell vector
		* @param[out] strCmds, the output script vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean CreateCrossSectionScript(const std::vector<NctiDisplayModelBody*>& pEdgeBodyVec, const std::vector<NctiTopoCell*>& pEdgeCellVec, std::vector<std::string>& strCmds);
		//Transform
		/**
		* @brief create the move script
		* @details create the move script
		* @param[in] pBaseModel, the base model
		* @param[in] strNameVec, the object name vector
		* @param[in] Vec, the move vector
		* @return the script
		*/
		static std::string CreateMovePyCommand(const std::vector<std::string>& strNameVec, const NctiVector& Vec);
		//mirror
		/**
		* @brief get center point and direction from selected cells 
		* @details get center point and direction from selected cells (circle and circle,or point and point)
		* @param[in] pBaseModel, the base model
		* @param[out] pt, the center point
		* @param[out] vec, the direction vector
		* @return true if success, false otherwise
		*/
		static Ncti_Boolean GetCenterPtAndDir(NctiBaseModel* pBaseModel, NctiPosition& pt, NctiVector& vec);
		/**
		* @brief create the mirror script
		* @details create the mirror script
		* @param[in] pBaseModel, the base model
		* @param[in] objNameVec, the object name vector
		* @param[in] pt, the mirror plane point
		* @param[in] vec, the mirror plane normal
		* @return the script vector
		*/
		static std::vector<std::string> CreateMirrorPyScript(NctiBaseModel* pBaseModel, const std::vector<std::string>& objNameVec, const NctiPosition& pt, const NctiVector& vec);
		//swept
		/**
		* @brief create the swept script
		* @details create the swept script
		* @param[in] pBaseModel, the base model
		* @param[in] resName, the swept name
		* @param[in] spineName, the spine name
		* @param[in] sectionName, the section name
		* @param[in] sweptMode, the swept mode
		* @return the script
		*/
		static std::string CreateSweptPyScript(NctiBaseModel* pBaseModel, const char* resName, const char* spineName, const char* sectionName, Ncti_Integer sweptMode);
		//trim
		/**
		* @brief create the trim script
		* @details create the trim script
		* @param[in] pBaseModel, the base model
		* @param[in] resName, the trim name
		* @param[in] sourceName, the source name
		* @param[in] su, the start u parameter
		* @param[in] eu, the end u parameter
		* @return the script
		*/
		static std::string CreateTrimPyScript(NctiBaseModel* pBaseModel, const char* resName, const char* sourceName, Ncti_Double su, Ncti_Double eu);
		/**
		* @brief create the trim script
		* @details create the trim script
		* @param[in] pBaseModel, the base model
		* @param[in] resName, the trim name
		* @param[in] sourceName, the source name
		* @param[in] su, the start u parameter string
		* @param[in] eu, the end u parameter string
		* @return the script
		*/
		static std::string CreateTrimPyScript(NctiBaseModel* pBaseModel, const char* resName, const char* sourceName, const char* su, const char* eu);
		//delete
		/**
		* @brief create the delete script
		* @details create the delete script
		* @param[in] pBaseModel, the base model
		* @param[in] name, the object name
		* @return the script
		*/
		static std::string CreateDeletePyScript(NctiBaseModel* pBaseModel, const char* name);

	};
}
#endif // !NctiCreateModelScriptPub_H
